package com.sunshine.gateway.util;

import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.crypto.GlobalBouncyCastleProvider;
import cn.hutool.json.JSONObject;
import cn.hutool.jwt.JWT;
import cn.hutool.jwt.JWTPayload;
import cn.hutool.jwt.JWTUtil;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;


@Component
public class JwtUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedissonClient redissonClient;

    // 静态实例引用，用于在静态方法中访问Spring注入的Bean
    private static JwtUtil jwtUtilInstance;

    @PostConstruct
    public void init() {
        jwtUtilInstance = this;
    }



    private static final Logger LOG = LoggerFactory.getLogger(JwtUtil.class);

    /**
     * 盐值很重要，不能泄漏.
     */
    private static final String key = "Sunshine8023-9941";

    /**
     * 创建JWT token
     * @param id 用户ID
     * @param username 用户账号
     * @return 生成的token字符串
     */
    public static String createToken(Long id, String username) {
        LOG.info("开始生成JWT token，id：{}，password：{}", id, username);
        GlobalBouncyCastleProvider.setUseBouncyCastle(false);
        DateTime now = DateTime.now();
        DateTime expTime = now.offsetNew(DateField.HOUR, 24);
        Map<String, Object> payload = new HashMap<>();
        // 签发时间
        payload.put(JWTPayload.ISSUED_AT, now);
        // 过期时间
        payload.put(JWTPayload.EXPIRES_AT, expTime);
        // 生效时间
        payload.put(JWTPayload.NOT_BEFORE, now);
        // 内容
        payload.put("id", id);
        payload.put("username", username);
        String token = JWTUtil.createToken(payload, key.getBytes());
        LOG.info("生成JWT token：{}", token);
        return token;
    }
    
    /**
     * 校验JWT token有效性
     * @param token 待校验的token
     * @return 校验结果，有效返回true，无效返回false
     */
    //校验
    /**
     * 校验JWT token有效性
     * @param token 待校验的token
     * @return 校验结果，有效返回true，无效返回false
     */
    public static boolean validate(String token) {
        LOG.info("开始JWT token校验，token：{}", token);
        
        // 设置不使用BouncyCastle加密库
        GlobalBouncyCastleProvider.setUseBouncyCastle(false);

        try {
            // 先进行JWT基本校验（检查签名、过期等）
            JWT jwt = JWTUtil.parseToken(token).setKey(key.getBytes());
            boolean basicValidate = jwt.validate(0);
            if (!basicValidate) {
                LOG.info("JWT基本校验失败");
                return false;
            }
            
            // 从token中解析用户信息
            JSONObject payloads = getJSONObject(token);
            Object userIdObj = payloads.get("id");
            
            if (userIdObj == null) {
                LOG.info("token中未找到用户ID");
                return false;
            }
            
            // 构造Redis key
            String userId = userIdObj.toString();
            String redisKey = "user_token:" + userId;
            
            // 从Redis中获取存储的token
            if (jwtUtilInstance != null) {
                LOG.info("开始从Redis中获取用户token，redisKey：{}", redisKey);
                Object storedToken = jwtUtilInstance.redissonClient.getBucket(redisKey).get();
                
                // 检查Redis中的token是否存在
                if (storedToken == null) {
                    LOG.info("Redis中未找到用户token，用户可能未登录或已过期");
                    return false;
                }
                
                // 比较客户端token与Redis中存储的token是否一致
                if (!storedToken.equals(token)) {
                    LOG.info("token与Redis中存储的不一致，可能已在其他设备登录");
                    return false;
                }
            }
            
            LOG.info("JWT token校验通过");
            return true;
            
        } catch (Exception e) {
            LOG.error("JWT token校验过程中发生错误", e);
            return false;
        }
    }

    /**
     * 从token中获取载荷数据
     * @param token JWT token
     * @return token中的载荷数据，已移除标准JWT字段
     */
    public static JSONObject getJSONObject(String token) {
        GlobalBouncyCastleProvider.setUseBouncyCastle(false);
        JWT jwt = JWTUtil.parseToken(token).setKey(key.getBytes());
        JSONObject payloads = jwt.getPayloads();
        payloads.remove(JWTPayload.ISSUED_AT);
        payloads.remove(JWTPayload.EXPIRES_AT);
        payloads.remove(JWTPayload.NOT_BEFORE);
        LOG.info("根据token获取原始内容：{}", payloads);
        return payloads;
    }


}